home *** CD-ROM | disk | FTP | other *** search
/ Compendium Deluxe 1 / LSD Compendium Deluxe 1.iso / a / programming / assembly / kcx25asc.lha / KCX / PackRow.Asm < prev    next >
Encoding:
Assembly Source File  |  1993-06-21  |  7.5 KB  |  250 lines
  1. ****************************************************************
  2. *
  3. *  Copyright 1988 by CREATIVE FOCUS.  This code is freely
  4. *  distributable as long as this notice is retained and no
  5. *  other conditions are imposed upon its redistribution.
  6. *
  7. *
  8. *  APACK.ASM --
  9. *
  10. *  A fully compatible replacement for Electronic Arts' PACKER.C
  11. *  routine.  Converts data according to the IFF ILBM cmpByteRun1
  12. *  compression protocol:
  13. *
  14. *     control bytes:
  15. *
  16. *        n =  0.. 127:   followed by n+1 bytes of data;
  17. *        n = -1..-127:   followed by byte to be repeated -n+1 times;
  18. *        n =     -128:   don't do no nada.
  19. *
  20. *     calling format:
  21. *
  22. *        long packrow(from, too, amt)
  23. *           char **from, /* pointer to source data pointer */
  24. *                **too;  /* pointer to destination data pointer */
  25. *           long amt;    /* number of bytes to compress */
  26. *
  27. *        return(number of bytes written to destination);
  28. *
  29. *     effects: 
  30. * 
  31. *         *from = *from + amt, and *too = *too + return; 
  32. *         return is "smart," that is, not greater than 
  33. *         MaxPackedSize = amt + ((amt+127) >> 7).
  34. * 
  35. *     By commenting out CHECK (below) you disable checking for runs 
  36. *     exceeding 128 bytes.  That CHECK is not needed if you are sure 
  37. *     the amt to be compressed is always 128 or less. 
  38. * 
  39. *  !!! DISCLAIMER !!!  You use this code entirely at your own 
  40. *  risk.  I don't warrantee its fitness for any purpose.  I 
  41. *  can't even guarantee the accuracy of anything I've said 
  42. *  about it, though I've tried my damndest to get it right. 
  43. *  I may, in fact, be completely out of my tiny little mind :-). 
  44. * 
  45. *  That being said, I can be reached for questions, comments, 
  46. *  or concerns at: 
  47. * 
  48. *        Dr. Gerald Hull 
  49. *        CREATIVE FOCUS 
  50. *        12 White Street 
  51. *        Binghamton, N.Y.  13901 
  52. *        (607) 648-4082 
  53. * 
  54. *        bix:    ghull 
  55. *        PLink:  DRJERRY 
  56. * 
  57. *************************************************************** 
  58.  
  59.       xdef  _packrow 
  60.  
  61. PT    equr  a0                -> beginning of replicate run (if any) 
  62. IX    equr  a1                -> end+1 of input line 
  63. IP    equr  a2                -> beginning of literal run (if any) 
  64. IQ    equr  a3                -> end+1 of lit and/or rep run (if any) 
  65. OP    equr  a4                -> end+1 of output line current pos 
  66. FP    equr  a6                frame pointer 
  67. SP    equr  a7                stack pointer 
  68.  
  69. RET    equr  d0                return value
  70. MX    equr  d1                check for maximum run = MAX
  71. AM    equr  d2                amount
  72. CH    equr  d3                character
  73.  
  74. REGS  reg   AM/CH/IP/IQ/OP
  75.  
  76. FRM   equ   8                 input line address
  77. TOO   equ   12                output line address
  78. AMT   equ   16                length of input line
  79.  
  80. MAX   equ   128               maximum encodable output run
  81. * CHECK equ   1                 turns on maximum row checking
  82.  
  83.  
  84. _packrow
  85.  
  86.  
  87. ***************     CASE 0:   GRAB PARAMS & INITIALIZE 
  88. CAS0 
  89.       link     FP,#0 
  90.       movem.l  REGS,-(SP) 
  91.       movea.l  FRM(FP),IP 
  92.       movea.l  (IP),IP        IP = *from 
  93.       movea.l  IP,IQ          IQ = IP 
  94.       movea.l  IQ,IX 
  95.       adda.l   AMT(FP),IX     IX = IP + amt 
  96.       movea.l  TOO(FP),OP 
  97.       movea.l  (OP),OP        OP = *too 
  98.  
  99.  
  100. ***************     CASE 1:   LITERAL RUN 
  101. CAS1 
  102.       movea.l  IQ,PT          adjust PT (no replicates yet!) 
  103.       move.b   (IQ)+,CH       grab character 
  104.       cmpa.l   IQ,IX          if input is finished 
  105.       beq.s    CAS5              branch to case 5 
  106.  
  107.       ifd      CHECK 
  108.       move.l   IQ,MX 
  109.       sub.l    IP,MX 
  110.       cmpi     #MAX,MX        if run has reached MAX 
  111.       beq.s    CAS6              branch to case 6 
  112.       endc 
  113.  
  114.       cmp.b    (IQ),CH        if next character != CH 
  115.       bne.s    CAS1              stay in case 1 
  116.  
  117. *                             else fall into case 2 
  118.  
  119.  
  120. ***************     CASE 2:   AT LEAST 2 BYTE REPEAT 
  121. CAS2 
  122.       move.b   (IQ)+,CH       grab character 
  123.       cmpa.l   IQ,IX          if input is finished 
  124.       beq.s    CAS7              branch to case 7 
  125.  
  126.       ifd      CHECK 
  127.       move.l   IQ,MX 
  128.       sub.l    IP,MX 
  129.       cmpi     #MAX,MX        if run has reached MAX 
  130.       beq.s    CAS6              branch to case 6 
  131.       endc 
  132.  
  133.       cmp.b    (IQ),CH        if next character != CH 
  134.       bne.s    CAS1              branch to case 1 
  135.  
  136. *                             else fall into case 3 
  137.  
  138.  
  139. ***************     CASE 3:   REPLICATE RUN 
  140. CAS3
  141.       move.b   (IQ)+,CH       grab character 
  142.       cmpa.l   IQ,IX          if input is finished 
  143.       beq.s    CAS7              branch to case 7 
  144.  
  145.       ifd      CHECK 
  146.       move.l   IQ,MX 
  147.       sub.l    PT,MX 
  148.       cmpi     #MAX,MX        if run has reached MAX 
  149.       beq.s    CAS4              branch to case 4 
  150.       endc 
  151.  
  152.       cmp.b    (IQ),CH        if next character = CH 
  153.       beq.s    CAS3              stay in case 3 
  154.  
  155. *                             else fall into case 4 
  156.  
  157.  
  158. ***************     CASE 4:   LIT AND/OR REP DUMP & CONTINUE 
  159. CAS4 
  160.       move.l   PT,AM 
  161.       sub.l    IP,AM          AM = PT - IP 
  162. *                             if no literal run 
  163.       beq.s    C41               branch to replicate run 
  164.  
  165.       subq     #1,AM          AM = AM - 1 
  166.       move.b   AM,(OP)+       output literal control byte 
  167.  
  168. C40   move.b   (IP)+,(OP)+    output literal run 
  169.       dbra     AM,C40 
  170.  
  171. C41   move.l   PT,AM 
  172.       sub.l    IQ,AM          AM = PT - IQ (negative result!) 
  173.       addq     #1,AM          AM = AM + 1 
  174.       move.b   AM,(OP)+       output replicate control byte 
  175.       move.b   CH,(OP)+       output repeated character 
  176.       movea.l  IQ,IP          reset IP 
  177.       bra.s    CAS1           branch to case 1 (not done) 
  178.  
  179.  
  180. ***************     CASE 5:   LITERAL DUMP & QUIT 
  181. CAS5 
  182.       move.l   IQ,AM 
  183.       sub.l    IP,AM          AM = IQ - IP (positive result > 0) 
  184.       subq     #1,AM          AM = AM - 1 
  185.       move.b   AM,(OP)+       output literal control byte 
  186.  
  187. C50   move.b   (IP)+,(OP)+    output literal run 
  188.       dbra     AM,C50 
  189.  
  190.       bra.s    CAS8           branch to case 8 (done) 
  191.  
  192.  
  193.       ifd      CHECK 
  194.  
  195. ***************     CASE 6:   LITERAL DUMP & CONTINUE 
  196. CAS6
  197.       move.l   IQ,AM 
  198.       sub.l    IP,AM          AM = IQ - IP (positive result > 0) 
  199.       subq     #1,AM          AM = AM - 1 
  200.       move.b   AM,(OP)+       output literal control byte 
  201.  
  202. C60   move.b   (IP)+,(OP)+    output literal run 
  203.       dbra     AM,C60 
  204.  
  205.       bra      CAS1           branch to case 1 (not done) 
  206.  
  207.       endc 
  208.  
  209.  
  210. ***************     CASE 7:   LIT AND/OR REP DUMP & FINISH 
  211. CAS7 
  212.       move.l   PT,AM 
  213.       sub.l    IP,AM          AM = PT - IP (positive result > 0) 
  214. *                             if no literal run 
  215.       beq.s    C71               branch to replicate run 
  216.  
  217.       subq     #1,AM          AM = AM - 1 
  218.       move.b   AM,(OP)+       output literal control byte 
  219.  
  220. C70   move.b   (IP)+,(OP)+    output literal run 
  221.       dbra     AM,C70 
  222.  
  223. C71   move.l   PT,AM 
  224.       sub.l    IQ,AM          AM = PT - IQ (negative result) 
  225.       addq     #1,AM          AM = AM + 1 
  226.       move.b   AM,(OP)+       output replicate control byte 
  227.       move.b   CH,(OP)+       output repeated character 
  228.  
  229. *                             fall into case 8 
  230.  
  231.  
  232. ***************     CASE 8:   ADJUST PARAMS & RETURN VALUE 
  233. CAS8 
  234.       movea.l  FRM(FP),PT     PT = **from 
  235.       move.l   IQ,(PT)        *from = *from + amt 
  236.       movea.l  TOO(FP),PT     PT = **too 
  237.  
  238.       move.l   OP,RET
  239.       sub.l    (PT),RET       return = OP - *too
  240.  
  241.       move.l   OP,(PT)       *too = *too + return 
  242.       movem.l  (SP)+,REGS 
  243.       UNLK     FP 
  244.       rts
  245.  
  246.  
  247.  
  248.  
  249.  
  250.